package com.senior.reference;

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.util.concurrent.TimeUnit;

public class ReferenceDemo {

    public static void main01(String[] args) throws InterruptedException {
        MyObject myObject = new MyObject();//这种默认的写法就是强应用
        //只要引用执行了实例对象，就不会被回收，强引用
        System.out.println("gc before"+myObject);

        myObject=null;//如果不把这个对象设置为null，发送GC也不会回收，
        // 只要这个对象还活着，是不会被回收的，因此强引用是造成OOM的原因

        System.gc();
        TimeUnit.SECONDS.sleep(1);
        System.out.println("gc After "+myObject);//gc之后还是有

    }

    public static void main02(String[] args)throws InterruptedException {

        SoftReference softReference = new SoftReference(new MyObject());
        System.out.println("gc before"+softReference);

        //这是内存够用的情况，before和After都有对象
        System.gc();
        TimeUnit.SECONDS.sleep(1);
        System.out.println("gc After "+softReference);//gc之后还是有

        //然后去吧这个对象做限制，然后搞成内存不够的样子，GC就会把这个软引用的对象给回收掉了
    }

    public static void main03(String[] args)throws InterruptedException {
        WeakReference softReference = new WeakReference(new MyObject());
        System.out.println("gc before"+softReference);

        //这是弱引用，发生了GC，就会直接把对象回收去
        System.gc();
        TimeUnit.SECONDS.sleep(1);
        System.out.println("gc After "+softReference);//gc之后还是有


    }

    public static void main(String[] args) {
        //虚引用要和引用队列配合使用
        ReferenceQueue referenceQueue = new ReferenceQueue();
        PhantomReference<MyObject> phantomReference = new PhantomReference<>(new MyObject(),referenceQueue);



    }

}
class MyObject{

    @Override
    protected void finalize() throws Throwable {
        System.out.println("------gc 回收会调用这个方法");
    }

}
